Programming concurrent applications is considered difficult and error-prone by a majority of professional developers. Most system developers struggle with this type of programming which is one reason why it remains outside the reach of most business application developers.
Concurrent algorithms are not always appropriate, however, when used for solving the right problems, they offer tremendous advantages in terms of performance and algorithmic simplicity. With the growing interest in developing programs that are distributed across wide-area networks, the need for concurrent programming tools is increasing as communication latencies grow rapidly and the cost of sequential execution sky-rockets.
One problem is, however, that the facilities for concurrency available to most programmers are low-level and complicated to use. Few programming languages offer any kind of support for concurrency. Conventionally, the programming languages that offer support for concurrency are special-purpose languages or languages that are used only within small academic communities.
Object-oriented (OO) frameworks such as J2EE and .NET brand environments have made the OO approach to program design mainstream. However, with its focus on shared memory, it leads to complex support for concurrency, support that is better suited for system programming than application programming. It is widely recognized that shared memory is one of the main obstacles to simple support for concurrency.
Accordingly, there exists a substantial need in the art to add support for concurrency to a mainstream OO language and to implement coexistence. Further, there is an unmet need for a system and/or method to allow programs to be developed that may either be run in one address space, distributed across several processes on a single computer, or distributed across a local-area or wide-area network, all without recoding the program. Central to this aspect is the notion of a “service”, which executes its own algorithmic (logical) thread. Moreover, there is an unmet need for a means of specifying message-based interfaces between services. In other words, there is a need to unify OO and message oriented languages in order to simplify application programming.
Conventional services with message-passing are defined by OCCAM, a special-purpose language developed in the 1980's which was designed and operable only on a specific hardware processor. Formal program specifications embedded in the programming language are not new. Eiffel, for example, offers a limited form of program specification support directly in the programming language itself. Eiffel is an advanced programming language created by Bertrand Meyer and developed by his company, Interactive Software Engineering (ISE).
However, separation of the protocol specification from the implementation is currently not available. This separation is extremely important to the ability to abstract the interaction of services with each other. For example, XLANG, the language underlying BizTalk, exposes the entire service message-exchange pattern as a protocol. However, this implementation is not separated from the interface, which makes static verification of contract conformance difficult.